Skip to main content

Handlers and Notify in Ansible

Handlers and Notify in Ansible

Handlers and Notify in Ansible

In Ansible, handlers are a special type of task that only run when notified by other tasks. They are commonly used for actions that should occur only when there is a change in the state of a resource, optimizing playbook runs by avoiding unnecessary operations.

How Handlers Work

  1. Definition: Handlers are defined like regular tasks but are placed under a handlers section in your playbook.
  2. Notification: A task can notify a handler when it makes a change, using the notify keyword.
  3. Execution: Handlers are executed at the end of a play, after all tasks have run, and only if they have been notified.

Example


---
- name: Example Playbook
  hosts: webservers
  tasks:
    - name: Install nginx
      apt:
        name: nginx
        state: present
      notify: Restart nginx  # Notify the handler if this task changes

    - name: Update nginx configuration
      template:
        src: nginx.conf.j2
        dest: /etc/nginx/nginx.conf
      notify: Restart nginx  # Notify the handler if this task changes

  handlers:
    - name: Restart nginx
      service:
        name: nginx
        state: restarted
    

Breakdown of the Example

  1. Tasks:
    • The first task installs nginx. If it is not already installed, it will notify the handler Restart nginx.
    • The second task updates the nginx configuration file. If the configuration changes, it will also notify the handler.
  2. Handlers:
    • The handler Restart nginx is defined under the handlers section. It restarts the nginx service.
  3. Execution Flow:
    • If either the installation of nginx or the configuration update results in a change, the handler will be called at the end of the playbook run to restart the service.

Key Points

  • Handlers run only when notified, avoiding unnecessary service restarts or actions unless a change occurs.
  • You can have multiple tasks notify the same handler, which will run only once, even if notified multiple times during the playbook run.
  • Handlers can be useful for tasks such as restarting services, clearing caches, or performing any other action that should occur only when a certain condition is met.

Feel free to ask if you have any specific scenarios or questions about using handlers in Ansible!

Comments

Popular posts from this blog

A Complete CI/CD Pipeline

Complete CI/CD Pipeline Using GitHub, Jenkins, Maven, SonarQube, Nexus, and Docker A well-designed CI/CD pipeline plays a critical role in modern DevOps practices by automating software delivery, improving code quality, and reducing deployment risks. In this article, I will explain how I build an automated CI/CD pipeline using GitHub, Jenkins, Maven, SonarQube, Nexus Repository, Docker, and Docker Hub. Source Code Management with GitHub The CI/CD workflow begins with storing the application source code in GitHub. Developers regularly push code changes or create pull requests to collaborate on features and bug fixes. Whenever new code is pushed to the repository, GitHub triggers Jenkins automatically through a webhook. This integration helps start the CI/CD pipeline without manual intervention. Code Checkout Stage in Jenkins The first stage of the pipeline is the checkout process. Jenkins connects to the GitHub repository and pulls the latest version of the source code. ...

Terraform for AWS: Step-by-Step Infrastructure Automation That Actually Works

How I Use Terraform to Provision and Manage AWS Infrastructure Efficiently Infrastructure as Code (IaC) has become a critical part of modern cloud operations, and Terraform is one of the most popular tools for automating cloud infrastructure deployment. In this article, I'll share how I use Terraform to build and manage AWS resources such as Virtual Private Clouds (VPCs), EC2 instances, Application Load Balancers (ALBs), and Auto Scaling Groups. Building AWS Infrastructure with Terraform My infrastructure deployment process begins by defining all AWS resources as code. This approach ensures consistency, repeatability, and easier management across multiple environments. The first step is creating a secure network architecture using a VPC. Within the VPC, I configure public and private subnets, route tables, internet gateways, and other networking components required for application deployment. Once the networking layer is ready, I deploy EC2 instances inside private su...

Master Linux Administration for DevOps: Powerful Commands, Troubleshooting Tips & Best Practices

Linux administration is one of the most important skills for anyone working in DevOps. From application servers and CI/CD platforms to containers and cloud infrastructure, Linux-based systems are widely used in modern technology environments. In my day-to-day DevOps activities, I regularly work with Linux commands to manage files, monitor processes, troubleshoot services, investigate network problems, analyze logs, and resolve production issues. This guide covers essential Linux administration concepts and commands that are useful for DevOps engineers, along with practical examples of how they can be applied during everyday troubleshooting. 1. Understanding Linux File Permissions Linux uses a permission system to control access to files and directories. The three basic permissions are: Read (r) – Allows a user to view the contents of a file or directory. Write (w) – Allows modifications to a file or directory. Execute (x) – Allows a file to be executed or a director...